package utils 
{
	import flash.events.Event;
	import flash.events.IEventDispatcher;
	import flash.net.URLLoader;
	import flash.net.URLRequest;

	/**
	 * ...
	 * @author miquel
	 */
	public class LoadFiles 
	{
		private static var DEBUG_LOADFILES:Boolean			= true;
		private static var m_ObjectSender:Object			= null;
		private static var m_fileXML:String					= "";

		private static var m_vQueue:Array					= null;
		private static var m_bCargando:Boolean				= false;	
		
		private static var m_uiArchivosACargar:uint			= 0;
		private static var m_uiArchivosCargados:uint		= 0;
		public static var m_bTotalArchivosCargados:Boolean	= false;
		
		public function LoadFiles() 
		{
		}
		
		public static function PreparaCargaMultiplesArchivos(_numArchivos:uint):void
		{
			m_bTotalArchivosCargados = false;
			m_uiArchivosCargados = 0;
			m_uiArchivosACargar = _numArchivos;
		}
		
		/**
		 * CargaArchivoXML: Ordena el almacenamiento de un archivo en memoria (xml)
		 * 		Tras las primeras pruebas se ha detectado que carga multiple de objetos no es posible por este metodo, por lo que, se ha 
		 * 		creado una cola de archivos para cargarlos uno a uno. 
		 * @param	_fileXML 
		 * @param	_sender: Es el objeto que ordenó la carga de xml, en CargaArchivoCompletada le avisamos a este objeto de la carga completa
		 * 					 Es necesario por el hecho de tener el esta funcion encapsulada.
		 */
		public static function CargaArchivoXML(_fileXML:String = "", _sender:Object = null):void
		{
			if(DEBUG_LOADFILES) trace ("LoadFiles.as::CargaArchivoXML " + _fileXML + " sender " + _sender);
			trace("LoadFiles.as::CargaArchivoXML::!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
			//primera pasada, cuando la cola no esta creada
			if (m_vQueue == null)
			{
				m_vQueue = new Array();
			}	

			//cuando se pase como argumento un archivo y un sender se guardarán en la cola
			if (_fileXML != "")
			{
				var aux:Object = new Object();
				aux.file = _fileXML;
				aux.sender = _sender;
				m_vQueue.push(aux);
			}
			
			//si no se esta cargando y la pila contiene elementos permite cargar el archivo
			if (!m_bCargando && m_vQueue.length != 0)
			{
				//se almacena el objeto que envio la orden para obtener el xml
				var l_object:Object = m_vQueue.shift()
				m_ObjectSender 	= l_object.sender;
				m_fileXML 		= l_object.file;
				
				CargaArchivoAux();
			}
		}
		
		/**
		 * CargaArchivoAux: funcion auxiliar a la anterior para conseguir la funcionalidad de carga de archivos multiple
		 * 		solo se llamará si no hay otro fichero cargando y la cola no esta vacia
		 */
		private static function CargaArchivoAux():void
		{
			//permite cargar el archivo
			var l_pCargador:URLLoader = null;
			l_pCargador = new URLLoader();
			if (l_pCargador != null)
			{
				//evento para localizar el final de la carga
				CargaArchivoEvento(l_pCargador);
				
				//peticion de carga del archivo
				var l_pArchivoPedido:URLRequest = new URLRequest(m_fileXML);
				if (l_pArchivoPedido != null)
				{
					l_pCargador.load(l_pArchivoPedido);
				}
			}
		}
		
		
		/**
		 * CargaArchivoEvento: Se pone a la escucha de la finalizacion de la carga de un archivo
		 * @param	evento
		 */
		private static function CargaArchivoEvento(evento:IEventDispatcher):void
		{
			if (DEBUG_LOADFILES) trace ("LoadFiles.as::CargaArchivoEvento:" + evento);
			
			//avisa que se esta cargando un archivo
			m_bCargando = true;
			
			//llamará a la funcion cuando acabe de cargar el archivo
			evento.addEventListener(Event.COMPLETE, CargaArchivoCompletada);
		}
		
		
		/**
		 * CargaArchivoCompletada: Deteccion de carga del archivo
		 * @param	e
		 */
		private static function CargaArchivoCompletada(e:Event):void
		{
			if (DEBUG_LOADFILES) trace ("LoadFiles.as::CargaArchivoCompletada:" + e);
			
			//obtencion de datos del archivo
			var l_pInfoFile:XML 	= null;
			var l_pLoader:URLLoader = e.target as URLLoader;
			
			if (l_pLoader != null)
			{
				l_pInfoFile = new XML(l_pLoader.data);
			}
			
			//fin de carga del archivo, llama sin parametros por si hay elementos en la cola de archivos a cargar
			m_uiArchivosCargados++;

			//envio al objeto emisor que la carga ha finalizado
			if(m_uiArchivosACargar == m_uiArchivosCargados) trace("********LoadFiles.as::CargaArchivoCompletada:m_uiArchivosACargar == m_uiArchivosCargados:" );
			m_ObjectSender.LoadComplete(l_pInfoFile, m_uiArchivosACargar == m_uiArchivosCargados);
			m_bCargando = false;
			CargaArchivoXML();
		}
		
		
		
	}

}